home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / et / et-2_2.lha / et2.2 / src / ObjList.C < prev    next >
C/C++ Source or Header  |  1990-12-21  |  7KB  |  453 lines
  1. //$ObjLink,ObjList,ObjListIter,RevObjListIter,ObjLink$
  2. #include "ObjList.h"
  3. #include "FixedStorage.h"
  4. #include "System.h"
  5. #include "Storage.h"
  6.  
  7. //---- ObjLink -----------------------------------------------------------------
  8.  
  9. MetaImpl(ObjLink, (TP(next), TP(previous), TP(op), 0));
  10.  
  11. ObjLink::ObjLink(ObjPtr a, ObjLink* n, ObjLink* p)
  12. { 
  13.     op= a; 
  14.     next= n; 
  15.     previous= p; 
  16. }
  17.  
  18. ObjLink::ObjLink(ObjPtr a, ObjLink *l)
  19. {
  20.     op= a;
  21.     next= l;
  22.     previous= l->previous;
  23.     l->previous->next= this;
  24.     l->previous= this;
  25. }
  26.  
  27. ObjLink::~ObjLink()
  28. {
  29. }
  30.  
  31. void ObjLink::FreeAll()
  32. {
  33.     if (op) {
  34.     op->FreeAll();
  35.     SafeDelete(op);
  36.     }
  37. }
  38.  
  39. void *ObjLink::operator new(size_t sz)
  40. {
  41.     return MemPools::Alloc(sz);
  42. }
  43.  
  44. void ObjLink::operator delete(void *vp)
  45. {
  46.     MemPools::Free(vp, sizeof(ObjLink)); 
  47. }
  48.  
  49. //---- ObjList -----------------------------------------------------------------
  50.  
  51. MetaImpl(ObjList, (TP(first), TP(last), 0));
  52.  
  53. ObjList::ObjList()
  54. {
  55.     first= last= 0;
  56. }
  57.  
  58. ObjList::~ObjList()
  59. {
  60.     register ObjLink *l, *ll;
  61.  
  62.     for(l= first; l; l= ll) {
  63.     ll= l->next;
  64.     SafeDelete(l);
  65.     }
  66.     first= last= 0;
  67. }
  68.  
  69. void ObjList::FreeAll()
  70. {
  71.     register ObjLink *l, *ll;
  72.  
  73.     for (l= first; l; l= ll) {
  74.     ll= l->next;
  75.     l->FreeAll();
  76.     SafeDelete(l);
  77.     }
  78.     first= last= 0;
  79.     size= 0;
  80. }
  81.  
  82. void ObjList::RemoveDeleted()
  83. {
  84.     register ObjLink *l, *p;
  85.  
  86.     l= first;
  87.     while (l) {
  88.     p= l;
  89.     l= l->next;
  90.     if (p->op->IsDeleted()) {
  91.         SafeDelete(p->op);
  92.         RemoveLink(p);
  93.     }
  94.     }
  95. }
  96.  
  97. void ObjList::Insert(ObjPtr a)
  98. {
  99.     if (CheckNotNull("Insert", a))
  100.     return;
  101.     CheckActiveIter("Insert");
  102.     first= new ObjLink(a, first, 0);
  103.     if (last == 0)
  104.     last= first;
  105.     else 
  106.     first->next->previous= first;
  107.     size++;
  108.     Changed();
  109. }
  110.  
  111. void ObjList::InsertObjLink(ObjPtr op, ObjLink *l)
  112. {
  113.     new ObjLink(op, l);
  114.     size++;
  115.     Changed();
  116. }
  117.  
  118. ObjLink *ObjList::FindObjLink(ObjPtr op, bool byPtr)
  119. {
  120.     register ObjLink *l;
  121.     for(l= first; l; l= l->next) {
  122.     if (l->op->IsDeleted())
  123.         continue;
  124.     if ((byPtr && l->op == op) || (!byPtr && l->op->IsEqual(op))) 
  125.         return l;
  126.     }
  127.     return 0;
  128. }
  129.  
  130. void ObjList::PrivInsertBefore(ObjPtr before, ObjPtr op, bool byPtr, char *name)
  131. {
  132.     register ObjLink *l;
  133.  
  134.     if (CheckNotNull(name, op))
  135.     return;
  136.     CheckActiveIter(name);
  137.     l= FindObjLink(before, byPtr);
  138.     if (l != 0) 
  139.        if (l == first)
  140.        Insert(op);
  141.        else 
  142.        InsertObjLink(op, l);
  143.     else
  144.     Error(name, "object not found");
  145. }
  146.  
  147. void ObjList::InsertBefore(ObjPtr before, ObjPtr op)
  148. {
  149.     PrivInsertBefore(before, op, FALSE, "InsertBefore");
  150. }
  151.  
  152. void ObjList::InsertBeforePtr(ObjPtr before, ObjPtr op)
  153. {
  154.     PrivInsertBefore(before, op, TRUE, "InsertBeforePtr");
  155. }
  156.  
  157. void ObjList::PrivInsertAfter(ObjPtr after, ObjPtr op, bool byPtr, char *name)
  158. {
  159.     register ObjLink *l;
  160.  
  161.     if (CheckNotNull(name, op))
  162.     return;
  163.     CheckActiveIter(name);
  164.     l= FindObjLink(after, byPtr);
  165.     if (l != 0) {
  166.     l= l->next;
  167.     if (l == 0)
  168.         Add(op); 
  169.     else 
  170.         InsertObjLink(op, l);
  171.     }
  172.     else
  173.     Error (name, "object not found");
  174. }
  175.  
  176. void ObjList::InsertAfter(ObjPtr after, ObjPtr op)
  177. {
  178.     PrivInsertAfter(after, op, FALSE, "InsertAfter");
  179. }
  180.  
  181. void ObjList::InsertAfterPtr(ObjPtr after, ObjPtr op)
  182. {
  183.     PrivInsertAfter(after, op, TRUE, "InsertAfterPtr");
  184. }
  185.  
  186. ObjPtr ObjList::Add(ObjPtr a)
  187. {
  188.     if (CheckNotNull("Add", a))
  189.     return 0;
  190.     CheckActiveIter("Add");
  191.     last= new ObjLink(a, 0, last);
  192.     if (first == 0)
  193.     first= last;
  194.     else
  195.     last->previous->next= last;
  196.     size++;
  197.     Changed();
  198.     return 0;
  199. }
  200.  
  201. ObjPtr ObjList::Replace(ObjPtr a, ObjPtr b)
  202. {
  203.     register ObjLink *l;
  204.     ObjPtr t;
  205.  
  206.     if (CheckNotNull("Replace", b))
  207.     return 0;
  208.     l= FindObjLink(a, TRUE);
  209.     if (l) {
  210.         t= l->op;
  211.         l->op= b;
  212.         Changed();
  213.         return t;
  214.     }
  215.     return 0;
  216. }
  217.  
  218. ObjPtr ObjList::First()
  219. {
  220.     if (Size() == 0)
  221.     return 0;
  222.     return GetAt(0);
  223. }
  224.  
  225. ObjPtr ObjList::Last()
  226. {
  227.     register ObjLink *l;
  228.  
  229.     if (Size() == 0)
  230.     return 0;
  231.     for(l= last; l; l= l->previous) 
  232.     if (!l->op->IsDeleted()) 
  233.         return l->op;
  234.     return 0;
  235. }
  236.  
  237. ObjPtr ObjList::Remove(ObjPtr a)
  238. {   
  239.     register ObjLink *l;
  240.     register ObjPtr op= 0;
  241.  
  242.     if (a == 0)
  243.     return 0;
  244.     for(l= first; l; l= l->next) {
  245.     if (l->op->IsEqual(a)) {
  246.         op= l->op;
  247.         RemoveLink(l);
  248.         break;
  249.     }
  250.     }
  251.     return op;
  252. }
  253.  
  254. ObjPtr ObjList::RemovePtr(ObjPtr a)
  255. {   
  256.     register ObjLink *l;
  257.     register ObjPtr op= 0;
  258.  
  259.     for(l= first; l; l= l->next) {
  260.     if (l->op == a) {
  261.         op= l->op;
  262.         RemoveLink(l);
  263.         break;
  264.     }
  265.     }
  266.     return op;
  267. }
  268.  
  269. void ObjList::RemoveLink(ObjLink *l)
  270. {
  271.     if (InIterator()) {
  272.     l->op= new DeletedObject;
  273.     AnnounceRemove();
  274.     }
  275.     else {
  276.     if (l->next)
  277.         l->next->previous= l->previous;
  278.     else
  279.         last= l->previous;
  280.     if (l->previous)
  281.         l->previous->next= l->next;
  282.     else
  283.         first= l->next;
  284.     delete l;
  285.     size--;
  286.     }
  287.     Changed();
  288. }
  289.  
  290. ObjPtr ObjList::GetAt(int index)
  291. {
  292.     register ObjLink *l;
  293.     register int i= 0;
  294.  
  295.     for(i= 0, l= first; l; l= l->next) {
  296.     if (!l->op->IsDeleted()) {
  297.         if (i == index)
  298.         return l->op;
  299.         i++;
  300.     }
  301.     }
  302.     return 0;
  303. }
  304.  
  305. ObjPtr ObjList::Before(ObjPtr before)
  306. {
  307.     register ObjLink *l;
  308.  
  309.     for (l = first; l; l= l->next) {
  310.     if (l->op->IsEqual(before)) {
  311.         l = l->previous;
  312.         if (l == 0)
  313.         return 0;
  314.         return l->op;
  315.     }
  316.     }    
  317.     if (l == 0)
  318.     Error ("Before", "object not found");
  319.     return 0;
  320. }
  321.  
  322. ObjPtr ObjList::After(ObjPtr after)
  323. {
  324.     register ObjLink *l;
  325.  
  326.     for (l = first; l; l= l->next) {
  327.     if (l->op->IsEqual(after)) {
  328.         l= l->next;
  329.         if (l == 0) 
  330.         return 0;
  331.         return l->op;
  332.     }
  333.     }
  334.     if (l == 0)
  335.     Error ("After", "object not found");
  336.     return 0;
  337. }
  338.  
  339. void ObjList::Empty(int)
  340. {
  341.     CheckActiveIter("Empty");
  342.     RemoveAll(this);
  343. }
  344.  
  345. ObjPtr ObjList::At(int i)
  346. {
  347.     return GetAt(i);
  348. }
  349.  
  350. Iterator *ObjList::MakeIterator() 
  351. { 
  352.     return new ObjListIter(this); 
  353. }
  354.  
  355. Iterator *ObjList::MakeReversedIterator () 
  356. { 
  357.     return new RevObjListIter(this); 
  358. }
  359.  
  360. //---- ObjListIter -------------------------------------------------------------
  361.  
  362. ObjListIter::ObjListIter(Collection *s)
  363. {
  364.     cs= (ObjList*)s; 
  365.     ce= cs ? cs->first : 0; 
  366. }
  367.  
  368. ObjListIter::~ObjListIter()
  369. {
  370.     IteratorEnd();
  371. }
  372.  
  373. void ObjListIter::Reset(Collection *s)
  374. {
  375.     if (s == 0)
  376.     s= Coll();
  377.     cs= (ObjList*)s;
  378.     ce= cs ? cs->first : 0;
  379.     Iterator::Reset(s);
  380. }
  381.  
  382. Collection *ObjListIter::Coll()
  383. {
  384.     return cs;
  385. }
  386.  
  387. Object* ObjListIter::operator()()
  388. {
  389.     Object *op;
  390.  
  391.     if (cs == 0)
  392.     return 0;
  393.     IteratorStart();
  394.  
  395.     while (ce && ce->op->IsDeleted())
  396.     ce= ce->next;
  397.  
  398.     if (ce) {
  399.     op= ce->op;
  400.     ce= ce->next;
  401.     return op;
  402.     }
  403.     ce= cs->first;
  404.     IteratorEnd();
  405.     return 0;
  406. }
  407.  
  408. void *ObjListIter::operator new(size_t sz)
  409. {
  410.     return MemPools::Alloc(sz);
  411. }
  412.  
  413. void ObjListIter::operator delete(void *vp)
  414. {
  415.     MemPools::Free(vp, sizeof(ObjListIter)); 
  416. }
  417.  
  418. //---- RevObjListIter ----------------------------------------------------------
  419.  
  420. RevObjListIter::RevObjListIter(ObjList *s) : ObjListIter(s)
  421. { 
  422.     cs= (ObjList*)s; 
  423.     ce= cs ? cs->last : 0;
  424. }
  425.  
  426. void RevObjListIter::Reset(Collection *s)
  427. {
  428.     ObjListIter::Reset(s);
  429.     ce= cs ? cs->last : 0;
  430. }
  431.  
  432. Object* RevObjListIter::operator()()
  433. {
  434.     Object *op;
  435.  
  436.     if (cs == 0)
  437.     return 0;
  438.     IteratorStart();
  439.  
  440.     while (ce && ce->op->IsDeleted())
  441.     ce= ce->previous;
  442.  
  443.     if (ce) {
  444.     op= ce->op;
  445.     ce= ce->previous;
  446.     return op;
  447.     }
  448.     ce= cs->last;
  449.     IteratorEnd();
  450.     return 0;
  451. }
  452.  
  453.